home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / listings / v_10_12 / 1012101a < prev    next >
Encoding:
Text File  |  1992-05-25  |  5.0 KB  |  238 lines
  1. /****************************************************/
  2. /*          LISTING 4. SEMDOS.C                     */
  3. /* Semantically parse a file of full DOS pathanames */
  4. /* Use the DFA state machine and the state table    */
  5. /*        defined in dostbl2.h                */
  6. /* Print out each component after parsing           */
  7. /* Parsing rule:                                    */
  8. /*      [DRIVE] [\] [PATH]* FILENAME [EXT] e        */
  9. /*  where   DRIVE    :=  a:                         */
  10. /*          ROOT     :=  \                          */
  11. /*          PATH     :=  ax* \                      */
  12. /*          FILENAME :=  ax* [.]                    */
  13. /*          EXT      :=  x[x][x]                    */
  14. /*          e        :=  '\n' (terminator)          */
  15. /*                                                  */
  16. /*  Copyright August 29, 1991 by Alan Cline        */
  17. /*      Carolla Development, Dublin, Ohio           */
  18. /****************************************************/
  19.  
  20. #include <stdio.h>
  21. #include <stdlib.h>
  22. #include <string.h>
  23. #include <ctype.h>
  24. #include "dfa.h"
  25. #include "dostbl2.h"
  26.  
  27.  
  28. #define TESTFILE    "testfile.dat"
  29. #define DELIMSTR    ":.\\"
  30. #define MAXFNAME    10
  31. #define MAXEXT         4
  32.  
  33. // Global storage to test parsing
  34. char drive;
  35. char pathname[MAXBUFLEN];
  36. char fname[MAXFNAME];
  37. char ext[MAXEXT];
  38.  
  39. void main(void)
  40. {
  41.     DFA_CLASS semdos_dfa;
  42.     FILE *fp;               // ptr to test file
  43.     short retval = OK;
  44.  
  45.     // Open the file of test names to parse
  46.     fp = fopen(TESTFILE, READ_TEXT);
  47.  
  48.     while (!feof(fp) && retval != ERR) {
  49.         retval = OK;
  50.  
  51.     // Init each component variable
  52.     drive = EMPTY;
  53.     memset(pathname, 0, MAXBUFLEN);
  54.     memset(fname, 0, MAXFNAME);
  55.     memset(ext, 0, MAXEXT);
  56.  
  57.     // Initialize the DFA and begin parsing
  58.     // Pass dfa, state table, override-tokenizer,
  59.     //      input file, delimeters
  60.     InitStateMachine(&semdos_dfa, &semdos_stt,
  61.         NULL, fp, DELIMSTR);
  62.  
  63.     retval = StateMachine(&semdos_dfa);
  64.     }
  65.  
  66.     // End test run; close file and quit
  67.     fclose(fp);
  68.     return;
  69. }
  70.  
  71. /************************************************/
  72. /* Application-specific routines for tokenizing */
  73. /************************************************/
  74.  
  75.  
  76. char *get_token(
  77.     DFA_CLASS *o)
  78. {
  79.     o->wp = &(o->workbuf[0]);
  80.     memset(o->workbuf, 0, MAXBUFLEN);
  81.     while (!feof(INFILE)) {
  82.         o->cp = getc(INFILE);
  83.     *(o->wp) = (char) o->cp;
  84.     o->wp++;
  85.     if (strchr(o->delim, o->cp) != NULL) {
  86.         break;
  87.     }
  88.  
  89.     // Force EOR and DOT to front of buffer
  90.     if (o->cp == (int) EOR) {
  91.             if (o->wp != o->workbuf+1) {
  92.             ungetc(o->cp, INFILE);
  93.         o->wp--;
  94.         }
  95.         break;
  96.     }
  97.     }        // end of while loop
  98.  
  99.     *(o->wp) = '\0';
  100.     return(o->workbuf);
  101. }
  102.  
  103.  
  104. /*********************************/
  105. /* Application-specific routines */
  106. /*********************************/
  107.  
  108. short isfbase(char *, short);
  109.  
  110. // Test DRIVE:= a:
  111. short isdrive(
  112.     char *token)
  113. {
  114.     return((token[1] == GS) &&
  115.             isalpha((int) token[0]));
  116. }
  117.  
  118. // Test EXT := x[x][x]
  119. short isext(
  120.     char *token)
  121. {
  122.     short len, k;
  123.     short retval = GOOD;
  124.  
  125.     len = strlen(token);
  126.     for (k=0; k < len; k++) {
  127.         if (!isalnum((int) token[k]))
  128.         retval = BAD;
  129.     }
  130.     return(retval);
  131. }
  132.  
  133. // Test for filebase := ax*
  134. short isfbase(
  135.     char *token,
  136.     short len)
  137. {
  138.     short k;
  139.     short retval = BAD;
  140.  
  141.     if ((len <= 9) && (isalpha((int) token[0]))) {
  142.         for (k=0; k < len; k++) {
  143.         if (!isalnum((int) token[k]))
  144.             break;
  145.         }
  146.         if (k == len)
  147.         retval = GOOD;
  148.     }
  149.     return(retval);
  150. }
  151.  
  152. // Test FNAME:= ax* [.]
  153. short isfname(
  154.     char *token)
  155. {
  156.     short len;
  157.  
  158.     len = (LASTBYTE(token) == DOT) ?
  159.             strlen(token) - 1 : strlen(token);
  160.  
  161.     return(isfbase(token, len));
  162. }
  163.  
  164. // Test PATH:= ax* \
  165. short ispath(
  166.     char *token)
  167. {
  168.     short retval = BAD;
  169.  
  170.     if (LASTBYTE(token) == FS) {
  171.         retval = isfbase(token, strlen(token) - 1);
  172.     }
  173.  
  174.     return(retval);
  175. }
  176.  
  177. // Test root character:= '\'
  178. short isroot(
  179.     char *token)
  180. {
  181.     return(*token == '\\');
  182. }
  183.  
  184.  
  185. /****************************************/
  186. /* Application-specific action routines */
  187. /****************************************/
  188.  
  189. // Save the drive letter tokenized;
  190. short appendpath(
  191.     char *token)
  192. {
  193.     strncat(pathname, token, strlen(token));
  194.     return(1);
  195. }
  196.  
  197. // Print out each component of the parsed pathname
  198. short cleanup(
  199.    char *token)
  200. {
  201.     IGNORE(token);
  202.     printf("File: %s\n\tDrive: %c\n",
  203.             fname, drive);
  204.     printf("\tPath: %s\n\tExtension: %s\n",
  205.             pathname, ext);
  206.     return(1);
  207. }
  208.  
  209.  
  210. // Save the drive letter
  211. short savedrive(
  212.     char *token)
  213. {
  214.     IGNORE(token);
  215.     drive = (toupper((int) token[0]));
  216.     return(1);
  217. }
  218.  
  219.  
  220. // Save the file extension
  221. short saveext(
  222.     char *token)
  223. {
  224.     strcpy(ext, token);
  225.     return(1);
  226. }
  227.  
  228.  
  229. // Save the filename
  230. short savefname(
  231.     char *token)
  232. {
  233.     strcpy(fname, token);
  234.     return(1);
  235. }
  236.  
  237.  
  238.